package com.example.baiduai.utils;

import com.example.baiduai.interfaces.Constat;
import com.example.baiduai.pojo.AbnormalPojo;
import com.google.common.cache.*;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;


@Slf4j
public class GooGleCacheUtils {


    /**
     * 现金扫码缓存
     */
    private static Cache<String,Boolean> cashPayCache = cashPayCache();


    /**
     * 扫码缓存
     */
    private static Cache<String,Boolean> ewmPayCache = ewmPayCache();


    /**
     * 收银箱开的缓存
     */
    private static  Cache<String,Boolean> cashierBboxCache = cashierBboxCache();

    /**
     * 私人二维码的缓存
     */
    private static  Cache<String,Boolean> QRCodeCache = QRCodeCache();


    /**
     *  现金扫码缓存  10秒过期
     * @return
     */
    private static Cache<String,Boolean> cashPayCache(){
        Cache<String, Boolean> payCache = CacheBuilder.newBuilder()
                // 设置并发级别为8，并发级别是指可以同时写缓存的线程数
                .concurrencyLevel(8)
                // 设置写缓存后过期时间
                .expireAfterWrite(20, TimeUnit.SECONDS)
                // 设置缓存容器的初始容量
                .initialCapacity(8)
                // 设置缓存最大容量,超过最大容量之后就会按照LRU最近虽少使用算法来移除缓存项
                .maximumSize(2)
                // 设置要统计缓存的命中率
                .recordStats()
                //移除通知
                .removalListener(new RemovalListener<Object, Object>() {
                    @Override
                    public void onRemoval(RemovalNotification<Object, Object> notification) {

                        if(ObjectUtils.isNotEmpty(notification.getValue())  && Boolean.valueOf(String.valueOf(notification.getValue())) && ObjectUtils.isNotEmpty(notification.getKey()) ){
                            String key = String.valueOf(notification.getKey());
                            String[] split = key.split("-");
                            if(split.length > 1){
                                // 判断有没有收银箱的缓存
                                Boolean bboxCache = GooGleCacheUtils.iscashierBboxCache(Constat.prefix.CASH_BBOX_PREFIX + split[1]);
                                if(ObjectUtils.isEmpty(bboxCache)){  // 付钱未打开钱箱 异常
//                                    AbnormalPojo abnormalPojo = new AbnormalPojo(split[1], TimeUtils.getCurrentTime_ymd_hms(), 2, 2);
//                                    HttpUtils.doPostJson(Constat.IP+Constat.URL,abnormalPojo);

                                }

                            }
                        }


                        log.info("现金扫码缓存 remove: {}, cause is: {}", notification.getKey(), notification.getCause());
                    }
                })
                .build();
       return payCache;
    }


    /**
     *  判断单个有没有 现金扫码缓存
     * @return
     */
    public static Boolean isCashPayCache(String key){
        return cashPayCache.getIfPresent(key);
    }

    /**
     *  现金扫码加入缓存
     * @return
     */
    public static void cashPayCachePut(String key){
        cashPayCache.put(key,true);
    }

    /**
     *  现金加入缓存
     * @return
     */
    public static void cashPayCachePut(String key,boolean flge){
        cashPayCache.put(key,flge);
    }


    /**
     * 扫码缓存   ***************************************************************************************************
     * @param
     */
    private static Cache<String,Boolean> ewmPayCache(){
        Cache<String, Boolean> payCache = CacheBuilder.newBuilder()
                // 设置并发级别为8，并发级别是指可以同时写缓存的线程数
                .concurrencyLevel(8)
                // 设置写缓存后过期时间
                .expireAfterWrite(2, TimeUnit.SECONDS)
                // 设置缓存容器的初始容量
                .initialCapacity(8)
                // 设置缓存最大容量,超过最大容量之后就会按照LRU最近虽少使用算法来移除缓存项
                .maximumSize(2)
                // 设置要统计缓存的命中率
                .recordStats()
                //移除通知
                .removalListener(new RemovalListener<Object, Object>() {
                    @Override
                    public void onRemoval(RemovalNotification<Object, Object> notification) {
                        log.info("remove: {}, cause is: {}", notification.getKey(), notification.getCause());
                    }
                })
                .build();
        return payCache;
    }

    /**
     *  判断单个有没有 扫码扫码缓存
     * @return
     */
    public static Boolean isewmPayCache(String key){
        return ewmPayCache.getIfPresent(key);
    }

    /**
     *  扫码支付加入缓存
     * @return
     */
    public static void ewmPayCachePut(String key){
        ewmPayCache.put(key,true);
    }

    public static void ewmPayCachePut(String key,boolean flag){
        ewmPayCache.put(key,flag);
    }


    /** *************************************
     * 收银箱开的缓存
     */

    private static Cache<String,Boolean> cashierBboxCache(){
        Cache<String, Boolean> cashierBboxCache = CacheBuilder.newBuilder()
                // 设置并发级别为8，并发级别是指可以同时写缓存的线程数
                .concurrencyLevel(8)
                // 设置写缓存后过期时间
                .expireAfterWrite(3, TimeUnit.SECONDS)
                // 设置缓存容器的初始容量
                .initialCapacity(8)
                // 设置缓存最大容量,超过最大容量之后就会按照LRU最近虽少使用算法来移除缓存项
                .maximumSize(2)
                // 设置要统计缓存的命中率
                .recordStats()
                //移除通知
                .removalListener(new RemovalListener<Object, Object>() {
                    @Override
                    public void onRemoval(RemovalNotification<Object, Object> notification) {
                        log.info("remove: {}, cause is: {}", notification.getKey(), notification.getCause());
                    }
                })
                .build();
        return cashierBboxCache;
    }

    /**
     *  判断单个有没有 收银箱缓存
     * @return
     */
    public static Boolean iscashierBboxCache(String key){
        return cashierBboxCache.getIfPresent(key);
    }

    /**
     *   收银箱加入缓存
     * @return
     */
    public static void cashierBboxCachePut(String key){
        cashierBboxCache.put(key,true);
    }

    /**
     *   收银箱加入缓存
     * @return
     */
    public static void cashierBboxCachePut(String key,boolean flge){
        cashierBboxCache.put(key,flge);
    }


    /**
     * ********************************************************
     * 私人二维码的缓存
     *
     */

    private static Cache<String,Boolean> QRCodeCache(){
        Cache<String, Boolean> qRCodeCache = CacheBuilder.newBuilder()
                // 设置并发级别为8，并发级别是指可以同时写缓存的线程数
                .concurrencyLevel(8)
                // 设置写缓存后过期时间
                .expireAfterWrite(2, TimeUnit.SECONDS)
                // 设置缓存容器的初始容量
                .initialCapacity(8)
                // 设置缓存最大容量,超过最大容量之后就会按照LRU最近虽少使用算法来移除缓存项
                .maximumSize(2)
                // 设置要统计缓存的命中率
                .recordStats()
                //移除通知
                .removalListener(new RemovalListener<Object, Object>() {
                    @Override
                    public void onRemoval(RemovalNotification<Object, Object> notification) {
                        log.info("remove: {}, cause is: {}", notification.getKey(), notification.getCause());
                    }
                })
                .build();
        return qRCodeCache;
    }

    /**
     *  判断单个有没有 收银箱缓存
     * @return
     */
    public static Boolean isQRCodeCache(String key){
        return QRCodeCache.getIfPresent(key);
    }

    /**
     *   收银箱加入缓存
     * @return
     */
    public static void qRCodeCachePut(String key){
        QRCodeCache.put(key,true);
    }

    /**
     *   收银箱加入缓存
     * @return
     */
    public static void qePut(String key,boolean flge){
        QRCodeCache.put(key,flge);
    }









    @SneakyThrows
    public static void main(String[] args) {
        Boolean cashPayCache = isCashPayCache("1111");
        if(ObjectUtils.isEmpty(cashPayCache)) {
            cashPayCachePut("1111");
            cashPayCachePut("1111",false);
            System.out.println("cashPayCache = " + isCashPayCache("1111"));
        }
        System.out.println("cashPayCache = " + cashPayCache);
    }








}
